// 自己做一下这道题吧, 就定义为, 删除故障开始(不包含)到故障恢复期间的数据
// 这道题并不难, 重点是题目解读有困难,好的,现在开始一下这道题的思路:
    // 首先收集错误角标, 去掉头部错误数据(新备份)
    // 然后使用双指针, 在周期范围内摸索, 数量不够, 整体移动, 每次移动, 都检查是否故障
        // 如果故障, 处理故障恢复, 最终, 是要根据角标, 把结果进行更新max
        //每更新一次, 重新定义滑动区间, 注意收尾的问题, 一直划到收尾?
                // 找回复到收尾
                // 找故障到收尾
const readline = require("readline");
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let m,t,p;
let initArr = [];


rl.on("line", (line) => {
    if(m === undefined) {
        [m, t, p] = line.trim().split(" ").map(Number)
    } else if (initArr.length === 0) {

        initArr = line.trim().split(" ").map(Number)
       let result = getResult(m,t,p, initArr);
        console.log(result)

        // 收尾
        m = t = p = undefined
        initArr.length = 0
    }
})

/**
 *
 * @param m {number} 周期
 * @param t {number} 次数
 * @param p {number} 故障恢复长
 * @param initArr {[number]} 初始数据
 * @return {number}  最大连续周期数
 */
function getResult(m,t,p, initArr) {
    // 先清理数据
    let errorIndex = []
    for(let i = 0; i < initArr.length;) {
        if(!valid(initArr, i)) {
            if(i === 0) {
                initArr.splice(0, 1)
                continue;
            } else {
                initArr[i] = initArr[ i - 1]
                errorIndex.push(i)
            }
        }
        i++;
    }

    // 接下来处理数据
    let result = 0
    if(errorIndex.length === 0) return initArr.length // 全对
    if(errorIndex.length === initArr.length) return result // 全错
    let left = 0
    let recordLeft = left;
    let right = 0
    let errorCount = t // 外层验证
    let rightCount = p // 内存验证
    // 双指针
    while(left <= right && left < initArr.length && right < initArr.length) {
        result = Math.max(result, right - recordLeft + 1) // 记录,防遗漏
        // ◆验证是否找到故障, 如果找到故障, 就马上处理故障恢复
        if(errorCount === 0) {
            // 找到故障, 需要故障恢复
            result = Math.max(result, right - recordLeft + 1)

            left = ++right;
            if(!errorIndex.includes(left)) {
                rightCount--
            }


            while(left <= right && left < initArr.length && right < initArr.length) {
                // 验证
                if(rightCount === 0) {
                    recordLeft = left = ++right; // 开始走外层
                    errorCount = t
                    if(left < initArr.length && errorIndex.includes(left)) {
                        errorCount--
                    }
                    rightCount = p
                    break;
                }

                // 移动
                right++;
                if(errorIndex.includes(right)) {
                    rightCount = p
                } else {
                    rightCount--
                }
            }

        } else {
            // 移动
            if(right - left + 1 < m){
                right++;
                if(errorIndex.includes(right)) {
                    errorCount--
                }

            } else {
                left++;
                if(errorIndex.includes(left - 1)) {
                    errorCount++
                }
                right++;
                if(errorIndex.includes(right)) {
                    errorCount--
                }
            }
        }
    }

    return result
}

function valid(initArr, index) {
    if(index === 0 && initArr[index] === 0) return true;
    if(initArr[index] <= 0) return false;
    if(index > 0 && initArr[index] < initArr[index - 1]) return false;
    if(index > 0 && initArr[index] - initArr[index - 1] >= 10) return false;
    return true;
}
